// bzoj1980
// 题意：给定m(<=1000000)个接口的位置，n(<=2000)台电脑，每台电脑都要接到
//       一个接口上，每个接口最多只能接一台电脑，费用是电脑和接口坐标差
//       绝对值（一维坐标，坐标long long就够）。求最小费用
// 
// 题解：咋看像km，不过范围太大。由于费用的特殊性，可以按坐标排序，
//       然后可以贪心的证明不会交叉，那么就可以进行一个O(n*m)的dp，
//       不过这样超时。注意到其实可以证明每个电脑只会从离他最近的前后
//       n个电脑转移过来，所以就可以优化下第二维状态，复杂度到O(n^2)。
//
// 统计：5140ms, too much, too much
//
// run: $exec < bfdiff.in
#include <cstdio>
#include <algorithm>

int const maxn = 2010;
long long const inf = (long long)(1) << 60;
int const maxm = 1001000;
long long a[maxm], b[maxn];
int near[maxn];
long long dp[2][maxm];
long long update[2][maxm];
int time_stamp;
int n, m;

template <class T>
T myabs(T const & a) { return (a >= 0 ? a : -a); }

int main()
{
	std::scanf("%d %d", &m, &n);
	for (int i = 1; i <= m; i++) std::scanf("%lld", &a[i]);
	for (int i = 1; i <= n; i++) std::scanf("%lld", &b[i]);
	std::sort(a + 1, a + m + 1);
	std::sort(b + 1, b + n + 1);

	for (int i = 1; i <= n; i++) {
		near[i] = std::lower_bound(a + 1, a + m + 1, b[i]) - a;
//		std::printf("---> %d\n", near[i]);
	}

	int now = 0, prev = 0;
	for (int i = 0; i <= m; i++) dp[1][i] = inf;

	long long ans = inf;
	for (int i = 1; i <= n; i++) {
		prev = now; now ^= 1; time_stamp++;
		for (int j = std::max(1, near[i] - n); j <= std::min(m, near[i] + n); j++) {
			dp[now][j] = inf;
			int tmp = j - 1;
			tmp = std::min(j - 1, std::min(m, near[i - 1] + n));
			if (update[prev][tmp] == time_stamp - 1) {
				dp[now][j] = dp[prev][tmp] + myabs(b[i] - a[j]);
				update[now][j] = time_stamp;
			}
			if (update[now][j - 1] == time_stamp) {
				dp[now][j] = std::min(dp[now][j], dp[now][j - 1]);
				update[now][j] = time_stamp;
			}
			update[now][j] = time_stamp;
			if (i == n && update[now][j] == time_stamp) ans = std::min(ans, dp[now][j]);
		}
	}
	std::printf("%lld\n", ans);
}

